/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package Dao;

import Dao.exceptions.IllegalOrphanException;
import Dao.exceptions.NonexistentEntityException;
import Dao.exceptions.PreexistingEntityException;
import java.io.Serializable;
import javax.persistence.Query;
import javax.persistence.EntityNotFoundException;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;
import Logico.Usuario;
import Logico.Periodista;
import java.util.ArrayList;
import java.util.List;
import Logico.Disciplina;
import Logico.Competencia;
import Logico.Evento;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;

/**
 *
 * @author usuario
 */
public class EventoJpaController implements Serializable {

    public EventoJpaController(EntityManagerFactory emf) {
        this.emf = emf;
    }
    protected EntityManagerFactory emf = null;

    public EntityManager getEntityManager() {
        return emf.createEntityManager();
    }

    public void create(Evento evento) throws PreexistingEntityException, Exception {
        if (evento.getPeriodistaList() == null) {
            evento.setPeriodistaList(new ArrayList<Periodista>());
        }
        if (evento.getDisciplinaList() == null) {
            evento.setDisciplinaList(new ArrayList<Disciplina>());
        }
        if (evento.getCompetenciaList() == null) {
            evento.setCompetenciaList(new ArrayList<Competencia>());
        }
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Usuario ceduladirectorlogistica = evento.getCeduladirectorlogistica();
            if (ceduladirectorlogistica != null) {
                ceduladirectorlogistica = em.getReference(ceduladirectorlogistica.getClass(), ceduladirectorlogistica.getCedula());
                evento.setCeduladirectorlogistica(ceduladirectorlogistica);
            }
            Usuario ceduladirectoradministrativo = evento.getCeduladirectoradministrativo();
            if (ceduladirectoradministrativo != null) {
                ceduladirectoradministrativo = em.getReference(ceduladirectoradministrativo.getClass(), ceduladirectoradministrativo.getCedula());
                evento.setCeduladirectoradministrativo(ceduladirectoradministrativo);
            }
            Usuario ceduladirectordeportivo = evento.getCeduladirectordeportivo();
            if (ceduladirectordeportivo != null) {
                ceduladirectordeportivo = em.getReference(ceduladirectordeportivo.getClass(), ceduladirectordeportivo.getCedula());
                evento.setCeduladirectordeportivo(ceduladirectordeportivo);
            }
            Usuario ceduladirectorevento = evento.getCeduladirectorevento();
            if (ceduladirectorevento != null) {
                ceduladirectorevento = em.getReference(ceduladirectorevento.getClass(), ceduladirectorevento.getCedula());
                evento.setCeduladirectorevento(ceduladirectorevento);
            }
            List<Periodista> attachedPeriodistaList = new ArrayList<Periodista>();
            for (Periodista periodistaListPeriodistaToAttach : evento.getPeriodistaList()) {
                periodistaListPeriodistaToAttach = em.getReference(periodistaListPeriodistaToAttach.getClass(), periodistaListPeriodistaToAttach.getIdperiodista());
                attachedPeriodistaList.add(periodistaListPeriodistaToAttach);
            }
            evento.setPeriodistaList(attachedPeriodistaList);
            List<Disciplina> attachedDisciplinaList = new ArrayList<Disciplina>();
            for (Disciplina disciplinaListDisciplinaToAttach : evento.getDisciplinaList()) {
                disciplinaListDisciplinaToAttach = em.getReference(disciplinaListDisciplinaToAttach.getClass(), disciplinaListDisciplinaToAttach.getIddisciplina());
                attachedDisciplinaList.add(disciplinaListDisciplinaToAttach);
            }
            evento.setDisciplinaList(attachedDisciplinaList);
            List<Competencia> attachedCompetenciaList = new ArrayList<Competencia>();
            for (Competencia competenciaListCompetenciaToAttach : evento.getCompetenciaList()) {
                competenciaListCompetenciaToAttach = em.getReference(competenciaListCompetenciaToAttach.getClass(), competenciaListCompetenciaToAttach.getIdcompetencia());
                attachedCompetenciaList.add(competenciaListCompetenciaToAttach);
            }
            evento.setCompetenciaList(attachedCompetenciaList);
            em.persist(evento);
            if (ceduladirectorlogistica != null) {
                ceduladirectorlogistica.getEventoList().add(evento);
                ceduladirectorlogistica = em.merge(ceduladirectorlogistica);
            }
            if (ceduladirectoradministrativo != null) {
                ceduladirectoradministrativo.getEventoList().add(evento);
                ceduladirectoradministrativo = em.merge(ceduladirectoradministrativo);
            }
            if (ceduladirectordeportivo != null) {
                ceduladirectordeportivo.getEventoList().add(evento);
                ceduladirectordeportivo = em.merge(ceduladirectordeportivo);
            }
            if (ceduladirectorevento != null) {
                ceduladirectorevento.getEventoList().add(evento);
                ceduladirectorevento = em.merge(ceduladirectorevento);
            }
            for (Periodista periodistaListPeriodista : evento.getPeriodistaList()) {
                periodistaListPeriodista.getEventoList().add(evento);
                periodistaListPeriodista = em.merge(periodistaListPeriodista);
            }
            for (Disciplina disciplinaListDisciplina : evento.getDisciplinaList()) {
                disciplinaListDisciplina.getEventoList().add(evento);
                disciplinaListDisciplina = em.merge(disciplinaListDisciplina);
            }
            for (Competencia competenciaListCompetencia : evento.getCompetenciaList()) {
                Evento oldEventoIdeventoOfCompetenciaListCompetencia = competenciaListCompetencia.getEventoIdevento();
                competenciaListCompetencia.setEventoIdevento(evento);
                competenciaListCompetencia = em.merge(competenciaListCompetencia);
                if (oldEventoIdeventoOfCompetenciaListCompetencia != null) {
                    oldEventoIdeventoOfCompetenciaListCompetencia.getCompetenciaList().remove(competenciaListCompetencia);
                    oldEventoIdeventoOfCompetenciaListCompetencia = em.merge(oldEventoIdeventoOfCompetenciaListCompetencia);
                }
            }
            em.getTransaction().commit();
        } catch (Exception ex) {
            if (findEvento(evento.getIdevento()) != null) {
                throw new PreexistingEntityException("Evento " + evento + " already exists.", ex);
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void edit(Evento evento) throws IllegalOrphanException, NonexistentEntityException, Exception {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Evento persistentEvento = em.find(Evento.class, evento.getIdevento());
            Usuario ceduladirectorlogisticaOld = persistentEvento.getCeduladirectorlogistica();
            Usuario ceduladirectorlogisticaNew = evento.getCeduladirectorlogistica();
            Usuario ceduladirectoradministrativoOld = persistentEvento.getCeduladirectoradministrativo();
            Usuario ceduladirectoradministrativoNew = evento.getCeduladirectoradministrativo();
            Usuario ceduladirectordeportivoOld = persistentEvento.getCeduladirectordeportivo();
            Usuario ceduladirectordeportivoNew = evento.getCeduladirectordeportivo();
            Usuario ceduladirectoreventoOld = persistentEvento.getCeduladirectorevento();
            Usuario ceduladirectoreventoNew = evento.getCeduladirectorevento();
            List<Periodista> periodistaListOld = persistentEvento.getPeriodistaList();
            List<Periodista> periodistaListNew = evento.getPeriodistaList();
            List<Disciplina> disciplinaListOld = persistentEvento.getDisciplinaList();
            List<Disciplina> disciplinaListNew = evento.getDisciplinaList();
            List<Competencia> competenciaListOld = persistentEvento.getCompetenciaList();
            List<Competencia> competenciaListNew = evento.getCompetenciaList();
            List<String> illegalOrphanMessages = null;
            for (Competencia competenciaListOldCompetencia : competenciaListOld) {
                if (!competenciaListNew.contains(competenciaListOldCompetencia)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain Competencia " + competenciaListOldCompetencia + " since its eventoIdevento field is not nullable.");
                }
            }
            if (illegalOrphanMessages != null) {
                throw new IllegalOrphanException(illegalOrphanMessages);
            }
            if (ceduladirectorlogisticaNew != null) {
                ceduladirectorlogisticaNew = em.getReference(ceduladirectorlogisticaNew.getClass(), ceduladirectorlogisticaNew.getCedula());
                evento.setCeduladirectorlogistica(ceduladirectorlogisticaNew);
            }
            if (ceduladirectoradministrativoNew != null) {
                ceduladirectoradministrativoNew = em.getReference(ceduladirectoradministrativoNew.getClass(), ceduladirectoradministrativoNew.getCedula());
                evento.setCeduladirectoradministrativo(ceduladirectoradministrativoNew);
            }
            if (ceduladirectordeportivoNew != null) {
                ceduladirectordeportivoNew = em.getReference(ceduladirectordeportivoNew.getClass(), ceduladirectordeportivoNew.getCedula());
                evento.setCeduladirectordeportivo(ceduladirectordeportivoNew);
            }
            if (ceduladirectoreventoNew != null) {
                ceduladirectoreventoNew = em.getReference(ceduladirectoreventoNew.getClass(), ceduladirectoreventoNew.getCedula());
                evento.setCeduladirectorevento(ceduladirectoreventoNew);
            }
            List<Periodista> attachedPeriodistaListNew = new ArrayList<Periodista>();
            for (Periodista periodistaListNewPeriodistaToAttach : periodistaListNew) {
                periodistaListNewPeriodistaToAttach = em.getReference(periodistaListNewPeriodistaToAttach.getClass(), periodistaListNewPeriodistaToAttach.getIdperiodista());
                attachedPeriodistaListNew.add(periodistaListNewPeriodistaToAttach);
            }
            periodistaListNew = attachedPeriodistaListNew;
            evento.setPeriodistaList(periodistaListNew);
            List<Disciplina> attachedDisciplinaListNew = new ArrayList<Disciplina>();
            for (Disciplina disciplinaListNewDisciplinaToAttach : disciplinaListNew) {
                disciplinaListNewDisciplinaToAttach = em.getReference(disciplinaListNewDisciplinaToAttach.getClass(), disciplinaListNewDisciplinaToAttach.getIddisciplina());
                attachedDisciplinaListNew.add(disciplinaListNewDisciplinaToAttach);
            }
            disciplinaListNew = attachedDisciplinaListNew;
            evento.setDisciplinaList(disciplinaListNew);
            List<Competencia> attachedCompetenciaListNew = new ArrayList<Competencia>();
            for (Competencia competenciaListNewCompetenciaToAttach : competenciaListNew) {
                competenciaListNewCompetenciaToAttach = em.getReference(competenciaListNewCompetenciaToAttach.getClass(), competenciaListNewCompetenciaToAttach.getIdcompetencia());
                attachedCompetenciaListNew.add(competenciaListNewCompetenciaToAttach);
            }
            competenciaListNew = attachedCompetenciaListNew;
            evento.setCompetenciaList(competenciaListNew);
            evento = em.merge(evento);
            if (ceduladirectorlogisticaOld != null && !ceduladirectorlogisticaOld.equals(ceduladirectorlogisticaNew)) {
                ceduladirectorlogisticaOld.getEventoList().remove(evento);
                ceduladirectorlogisticaOld = em.merge(ceduladirectorlogisticaOld);
            }
            if (ceduladirectorlogisticaNew != null && !ceduladirectorlogisticaNew.equals(ceduladirectorlogisticaOld)) {
                ceduladirectorlogisticaNew.getEventoList().add(evento);
                ceduladirectorlogisticaNew = em.merge(ceduladirectorlogisticaNew);
            }
            if (ceduladirectoradministrativoOld != null && !ceduladirectoradministrativoOld.equals(ceduladirectoradministrativoNew)) {
                ceduladirectoradministrativoOld.getEventoList().remove(evento);
                ceduladirectoradministrativoOld = em.merge(ceduladirectoradministrativoOld);
            }
            if (ceduladirectoradministrativoNew != null && !ceduladirectoradministrativoNew.equals(ceduladirectoradministrativoOld)) {
                ceduladirectoradministrativoNew.getEventoList().add(evento);
                ceduladirectoradministrativoNew = em.merge(ceduladirectoradministrativoNew);
            }
            if (ceduladirectordeportivoOld != null && !ceduladirectordeportivoOld.equals(ceduladirectordeportivoNew)) {
                ceduladirectordeportivoOld.getEventoList().remove(evento);
                ceduladirectordeportivoOld = em.merge(ceduladirectordeportivoOld);
            }
            if (ceduladirectordeportivoNew != null && !ceduladirectordeportivoNew.equals(ceduladirectordeportivoOld)) {
                ceduladirectordeportivoNew.getEventoList().add(evento);
                ceduladirectordeportivoNew = em.merge(ceduladirectordeportivoNew);
            }
            if (ceduladirectoreventoOld != null && !ceduladirectoreventoOld.equals(ceduladirectoreventoNew)) {
                ceduladirectoreventoOld.getEventoList().remove(evento);
                ceduladirectoreventoOld = em.merge(ceduladirectoreventoOld);
            }
            if (ceduladirectoreventoNew != null && !ceduladirectoreventoNew.equals(ceduladirectoreventoOld)) {
                ceduladirectoreventoNew.getEventoList().add(evento);
                ceduladirectoreventoNew = em.merge(ceduladirectoreventoNew);
            }
            for (Periodista periodistaListOldPeriodista : periodistaListOld) {
                if (!periodistaListNew.contains(periodistaListOldPeriodista)) {
                    periodistaListOldPeriodista.getEventoList().remove(evento);
                    periodistaListOldPeriodista = em.merge(periodistaListOldPeriodista);
                }
            }
            for (Periodista periodistaListNewPeriodista : periodistaListNew) {
                if (!periodistaListOld.contains(periodistaListNewPeriodista)) {
                    periodistaListNewPeriodista.getEventoList().add(evento);
                    periodistaListNewPeriodista = em.merge(periodistaListNewPeriodista);
                }
            }
            for (Disciplina disciplinaListOldDisciplina : disciplinaListOld) {
                if (!disciplinaListNew.contains(disciplinaListOldDisciplina)) {
                    disciplinaListOldDisciplina.getEventoList().remove(evento);
                    disciplinaListOldDisciplina = em.merge(disciplinaListOldDisciplina);
                }
            }
            for (Disciplina disciplinaListNewDisciplina : disciplinaListNew) {
                if (!disciplinaListOld.contains(disciplinaListNewDisciplina)) {
                    disciplinaListNewDisciplina.getEventoList().add(evento);
                    disciplinaListNewDisciplina = em.merge(disciplinaListNewDisciplina);
                }
            }
            for (Competencia competenciaListNewCompetencia : competenciaListNew) {
                if (!competenciaListOld.contains(competenciaListNewCompetencia)) {
                    Evento oldEventoIdeventoOfCompetenciaListNewCompetencia = competenciaListNewCompetencia.getEventoIdevento();
                    competenciaListNewCompetencia.setEventoIdevento(evento);
                    competenciaListNewCompetencia = em.merge(competenciaListNewCompetencia);
                    if (oldEventoIdeventoOfCompetenciaListNewCompetencia != null && !oldEventoIdeventoOfCompetenciaListNewCompetencia.equals(evento)) {
                        oldEventoIdeventoOfCompetenciaListNewCompetencia.getCompetenciaList().remove(competenciaListNewCompetencia);
                        oldEventoIdeventoOfCompetenciaListNewCompetencia = em.merge(oldEventoIdeventoOfCompetenciaListNewCompetencia);
                    }
                }
            }
            em.getTransaction().commit();
        } catch (Exception ex) {
            String msg = ex.getLocalizedMessage();
            if (msg == null || msg.length() == 0) {
                Integer id = evento.getIdevento();
                if (findEvento(id) == null) {
                    throw new NonexistentEntityException("The evento with id " + id + " no longer exists.");
                }
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Evento evento;
            try {
                evento = em.getReference(Evento.class, id);
                evento.getIdevento();
            } catch (EntityNotFoundException enfe) {
                throw new NonexistentEntityException("The evento with id " + id + " no longer exists.", enfe);
            }
            List<String> illegalOrphanMessages = null;
            List<Competencia> competenciaListOrphanCheck = evento.getCompetenciaList();
            for (Competencia competenciaListOrphanCheckCompetencia : competenciaListOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Evento (" + evento + ") cannot be destroyed since the Competencia " + competenciaListOrphanCheckCompetencia + " in its competenciaList field has a non-nullable eventoIdevento field.");
            }
            if (illegalOrphanMessages != null) {
                throw new IllegalOrphanException(illegalOrphanMessages);
            }
            Usuario ceduladirectorlogistica = evento.getCeduladirectorlogistica();
            if (ceduladirectorlogistica != null) {
                ceduladirectorlogistica.getEventoList().remove(evento);
                ceduladirectorlogistica = em.merge(ceduladirectorlogistica);
            }
            Usuario ceduladirectoradministrativo = evento.getCeduladirectoradministrativo();
            if (ceduladirectoradministrativo != null) {
                ceduladirectoradministrativo.getEventoList().remove(evento);
                ceduladirectoradministrativo = em.merge(ceduladirectoradministrativo);
            }
            Usuario ceduladirectordeportivo = evento.getCeduladirectordeportivo();
            if (ceduladirectordeportivo != null) {
                ceduladirectordeportivo.getEventoList().remove(evento);
                ceduladirectordeportivo = em.merge(ceduladirectordeportivo);
            }
            Usuario ceduladirectorevento = evento.getCeduladirectorevento();
            if (ceduladirectorevento != null) {
                ceduladirectorevento.getEventoList().remove(evento);
                ceduladirectorevento = em.merge(ceduladirectorevento);
            }
            List<Periodista> periodistaList = evento.getPeriodistaList();
            for (Periodista periodistaListPeriodista : periodistaList) {
                periodistaListPeriodista.getEventoList().remove(evento);
                periodistaListPeriodista = em.merge(periodistaListPeriodista);
            }
            List<Disciplina> disciplinaList = evento.getDisciplinaList();
            for (Disciplina disciplinaListDisciplina : disciplinaList) {
                disciplinaListDisciplina.getEventoList().remove(evento);
                disciplinaListDisciplina = em.merge(disciplinaListDisciplina);
            }
            em.remove(evento);
            em.getTransaction().commit();
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public List<Evento> findEventoEntities() {
        return findEventoEntities(true, -1, -1);
    }

    public List<Evento> findEventoEntities(int maxResults, int firstResult) {
        return findEventoEntities(false, maxResults, firstResult);
    }

    private List<Evento> findEventoEntities(boolean all, int maxResults, int firstResult) {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            cq.select(cq.from(Evento.class));
            Query q = em.createQuery(cq);
            if (!all) {
                q.setMaxResults(maxResults);
                q.setFirstResult(firstResult);
            }
            return q.getResultList();
        } finally {
            em.close();
        }
    }

    public Evento findEvento(Integer id) {
        EntityManager em = getEntityManager();
        try {
            return em.find(Evento.class, id);
        } finally {
            em.close();
        }
    }

    public int getEventoCount() {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            Root<Evento> rt = cq.from(Evento.class);
            cq.select(em.getCriteriaBuilder().count(rt));
            Query q = em.createQuery(cq);
            return ((Long) q.getSingleResult()).intValue();
        } finally {
            em.close();
        }
    }
    
}
